home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 25 / Cream of the Crop 25.iso / bbs / dgwrl201.zip / DOG201.RES / DOGIGM4.ZIP / DWRLDIGM.DOC < prev    next >
Text File  |  1996-11-14  |  7KB  |  183 lines
  1. Generic Data Structure of DogWorld's Note Records.
  2. Your program should be able to add/append this info
  3. to the end of the users note.x file.
  4.  
  5.  
  6. Byte           Data
  7. Position       Type     Description
  8. -----------------------------------------------------------------------
  9.   1 to   2     int      Received Status (always zero for new notes)
  10.   3 to  18     char     1st Code [optional] (see MAILCODE.DOC)
  11.  19 to  34     char     2nd Code [optional]   "     "
  12.  35 to  50     char     3rd Code [optional]   "     "
  13.  51 to 215     char     Title and border of note.
  14.                         (A (`n) should seperate the title and border.
  15.                         Place a backquote(`) inside bytes 51 and 52 to
  16.                         supress the display of the title and prompt. 
  17. 216 to 715     char     Body of the note. Place a backquote(`) inside
  18.                         bytes 216 and 217 to supress the display of the
  19.                         body and the (MORE) prompt.
  20. (Total: 715 bytes)
  21.  
  22.  
  23. NOTE! - Pascal programmers should define the "C" char strings as an
  24. array of characters for proper translation.
  25.  
  26. EXAMPLE:
  27.  
  28. DogNote = Record
  29.   Received  : Integer;                  { set this to zero   }
  30.   Code1     : Array[1..16] Of Char;     { 1st mail code      }
  31.   Code2     : Array[1..16] Of Char;     { 2nd mail code      }
  32.   Code3     : Array[1..16] Of Char;     { 3rd mail code      }
  33.   Title     : Array[1..165] Of Char;    { Title and border   }
  34.   Body      : Array[1..500] Of Char;    { Body of note       }
  35. END;
  36.  
  37.  
  38.  
  39.  
  40. /* C version - Copyright 1996 by Ken Cothran.  All rights reserved.  */
  41. /* You have my permission to include this code in your own programs. */
  42. /*
  43. /* You can simulate direct access through mail codes by using the    */
  44. /* special code (``) double backquote for both the title and body of */
  45. /* the note. When DogWorld processes a note like this, it skips the  */
  46. /* display of the title/body and doesn't show the (MORE) prompt.     */
  47.  
  48.                        /* Structure of one note record       */
  49. typedef struct         /* Each note record is 715 bytes long */
  50. {
  51.     int received;                      /* 0 if not read, else 1       */
  52.     char extra1[16];                   /* mail code, else 0           */
  53.     char extra2[16];                   /* mail code2, else 0          */
  54.     char extra3[16];                   /* mail code3, else 0          */
  55.     char header[165];                  /* top line of text and border */
  56.     char body[500];                    /* body of message             */
  57. } note_rec;
  58.  
  59.                                       
  60. /* Sample C Function to write a proper DogWorld note record              */
  61. /* Note that in most cases you will not want these notes displayed after */
  62. /* your IGM returns to DogWorld. You will only want the codes to be      */
  63. /* processed. In this case you should use the invisible note marker (``) */
  64. /* double back-quote for both the title and body of your  note.          */
  65. /* note. Example: WriteNote("``", "``", `G100, "", "");                  */
  66. /* This adds 100 bones to player, simulating direct access to data file  */
  67.  
  68.  
  69. void WriteNote(char *title,   /* Title of note */
  70.                char *body,    /* Body of note */
  71.                char *code1,   /* First code [optional] */
  72.                char *code2,   /* Second code [optional] */
  73.                char *code3);  /* Third code [optional] */
  74. FILE *AppendShareFile(char *FileName, char *FileMode, int *FileHandle);
  75. void CloseExclusiveShareFile(FILE *pFile, int FileHandle);
  76.  
  77.  
  78. void WriteNote(char *title, char *body, char *code1, char *code2, char *code3)
  79. {
  80.     char HeadHold[164], NoteFilename[81], NoteFileHold[10];
  81.     FILE *nfile; int hnote;
  82.     note_rec tnote;
  83.  
  84.     /* The path to DogWorld is stored in the global variable DogPath      */
  85.     /* Setup your IGM to retreive this path from an external data file.   */
  86.     /* Player record # (shown as 'record') is read from the INFO.x file.  */  
  87.  
  88.     /* Put together complete path and name of the NOTE.x file             */
  89.     strcpy(NoteFilename, DogPath);
  90.     sprintf(NoteFileHold,"NOTE.%d", record);
  91.     strcat(NoteFilename, NoteFileHold);
  92.     trim(NoteFilename);
  93.     NoteFileHold[0]='\0';
  94.  
  95.     tnote.received=0;    /* <--- Always set this to zero!          */
  96.  
  97.     /* Put together the note title, including border                      */
  98.     strcpy(HeadHold, title);
  99.     strcat(HeadHold, "`n`@---:---:---:---:---:---:---:---:---:---:---:---:---`n");
  100.     strncpy(tnote.header, HeadHold, 165);
  101.  
  102.     /* Setup the body of the note */
  103.     strncpy(tnote.body,body,500);
  104.  
  105.     /* Setup the code fields     */
  106.     strncpy(tnote.extra1,code1,16);
  107.     strncpy(tnote.extra2,code2,16);
  108.     strncpy(tnote.extra3,code3,16);
  109.  
  110.     /* Attempt to open the NOTE.x file. If success, append the new record */
  111.     if((nfile=AppendShareFile(NoteFilename, "ab", &hnote))==NULL)
  112.     {
  113.         od_printf("Can't open file: %s.", NoteFilename);
  114.     }
  115.     else
  116.     {
  117.         fseek(nfile, 0L, SEEK_END);
  118.         fwrite(&tnote, 1, sizeof(note_rec), nfile);
  119.         CloseExclusiveShareFile(nfile, hnote);
  120.     }
  121. }
  122.  
  123.  
  124. /* Function to do exclusive file open */
  125.  
  126. #include <share.h>
  127. #include <sys\stat.h>
  128. #include <fcntl.h>
  129. #include <errno.h>
  130. #include <stdio.h>
  131. #include <time.h>                         /* for struct tm */
  132. #include <io.h>
  133.  
  134.  
  135. #define WAIT_FOR_FILE      20
  136.  
  137.  
  138. FILE *AppendShareFile(char *FileName, char *FileMode, int *FileHandle)
  139. {
  140.     if(multi_node)        /* Get multi_node value from INFO.x (line 32) */
  141.     {
  142.         FILE *fpFile = NULL;
  143.         time_t StartTime = time(NULL);
  144.         int hFile;
  145.  
  146.         while((hFile = sopen(FileName,O_BINARY|O_APPEND|O_CREAT|O_RDWR,
  147.             SH_DENYRW,S_IREAD|S_IWRITE)) == -1)
  148.         {
  149.             if(errno != EACCES ||
  150.                 difftime(time(NULL), StartTime) >= WAIT_FOR_FILE)
  151.                 break;
  152.             od_kernel();    /* If using OpenDoors call od_kernel to  */
  153.         }                   /* keep things updated.                  */
  154.         if(hFile != -1)
  155.         {
  156.             fpFile = fdopen(hFile, FileMode);
  157.             if(fpFile == NULL)
  158.             {
  159.                 close(hFile);
  160.             }
  161.         }
  162.         *FileHandle = hFile;
  163.         return(fpFile);
  164.     }
  165.     else
  166.     {
  167.         (void)FileHandle;
  168.         return(fopen(FileName, FileMode));
  169.     }
  170. }
  171.  
  172.  
  173. void CloseExclusiveShareFile(FILE *pFile, int FileHandle)
  174. {
  175.     fclose(pFile);
  176.  
  177.     if(multi_node)    /* <---- Get from info.x */
  178.         close(FileHandle);
  179.     else
  180.         (void)FileHandle;
  181. }
  182.  
  183.